// utils/index.js
// 通用工具函数

/**
 * 格式化日期
 * @param {Date|string|number} date - 日期
 * @param {string} format - 格式化模板
 * @returns {string}
 */
export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
  if (!date) return '';
  const d = new Date(date);
  
  const year = d.getFullYear();
  const month = String(d.getMonth() + 1).padStart(2, '0');
  const day = String(d.getDate()).padStart(2, '0');
  const hours = String(d.getHours()).padStart(2, '0');
  const minutes = String(d.getMinutes()).padStart(2, '0');
  const seconds = String(d.getSeconds()).padStart(2, '0');
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds);
}

/**
 * 计算相对时间（如：3分钟前）
 * @param {Date|string|number} date - 日期
 * @returns {string}
 */
export function getRelativeTime(date) {
  if (!date) return '';
  const now = new Date();
  const d = new Date(date);
  const diff = now - d;
  
  const minute = 60 * 1000;
  const hour = 60 * minute;
  const day = 24 * hour;
  const week = 7 * day;
  const month = 30 * day;
  const year = 365 * day;
  
  if (diff < minute) {
    return '刚刚';
  } else if (diff < hour) {
    return `${Math.floor(diff / minute)}分钟前`;
  } else if (diff < day) {
    return `${Math.floor(diff / hour)}小时前`;
  } else if (diff < week) {
    return `${Math.floor(diff / day)}天前`;
  } else if (diff < month) {
    return `${Math.floor(diff / week)}周前`;
  } else if (diff < year) {
    return `${Math.floor(diff / month)}个月前`;
  } else {
    return `${Math.floor(diff / year)}年前`;
  }
}

/**
 * 深拷贝对象
 * @param {any} obj - 要拷贝的对象
 * @returns {any}
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  if (typeof obj === 'object') {
    const clonedObj = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key]);
      }
    }
    return clonedObj;
  }
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function}
 */
export function throttle(func, wait) {
  let timeout = null;
  let lastRun = 0;
  
  return function(...args) {
    const now = Date.now();
    const remaining = wait - (now - lastRun);
    
    if (remaining <= 0) {
      if (timeout) {
        clearTimeout(timeout);
        timeout = null;
      }
      lastRun = now;
      func.apply(this, args);
    } else if (!timeout) {
      timeout = setTimeout(() => {
        lastRun = Date.now();
        timeout = null;
        func.apply(this, args);
      }, remaining);
    }
  };
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function}
 */
export function debounce(func, wait) {
  let timeout = null;
  
  return function(...args) {
    const later = () => {
      timeout = null;
      func.apply(this, args);
    };
    
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

/**
 * 验证手机号格式
 * @param {string} phone - 手机号
 * @returns {boolean}
 */
export function isValidPhone(phone) {
  return /^1[3-9]\d{9}$/.test(phone);
}

/**
 * 验证邮箱格式
 * @param {string} email - 邮箱
 * @returns {boolean}
 */
export function isValidEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

/**
 * 生成唯一ID
 * @returns {string}
 */
export function generateId() {
  return Date.now().toString(36) + Math.random().toString(36).substr(2);
}

/**
 * 本地存储封装 - 同步版本
 */
export const storage = {
  set(key, value) {
    try {
      const jsonValue = JSON.stringify(value);
      uni.setStorageSync(key, jsonValue);
    } catch (e) {
      console.error('存储数据失败:', e);
    }
  },
  
  get(key, defaultValue = null) {
    try {
      const jsonValue = uni.getStorageSync(key);
      return jsonValue ? JSON.parse(jsonValue) : defaultValue;
    } catch (e) {
      console.error('读取数据失败:', e);
      return defaultValue;
    }
  },
  
  remove(key) {
    try {
      uni.removeStorageSync(key);
    } catch (e) {
      console.error('删除数据失败:', e);
    }
  },
  
  clear() {
    try {
      uni.clearStorageSync();
    } catch (e) {
      console.error('清空数据失败:', e);
    }
  }
};

/**
 * 本地存储封装 - Promise版本
 */
export const storageAsync = {
  /**
   * 存储数据
   * @param {string} key - 存储键名
   * @param {any} value - 存储值
   * @returns {Promise<void>}
   */
  async set(key, value) {
    return new Promise((resolve, reject) => {
      try {
        const jsonValue = JSON.stringify(value);
        uni.setStorageSync(key, jsonValue);
        resolve();
      } catch (error) {
        console.error('Storage set error:', error);
        reject(error);
      }
    });
  },

  /**
   * 获取数据
   * @param {string} key - 存储键名
   * @returns {Promise<any>}
   */
  async get(key) {
    return new Promise((resolve, reject) => {
      try {
        const jsonValue = uni.getStorageSync(key);
        resolve(jsonValue ? JSON.parse(jsonValue) : null);
      } catch (error) {
        console.error('Storage get error:', error);
        reject(error);
      }
    });
  },

  /**
   * 删除数据
   * @param {string} key - 存储键名
   * @returns {Promise<void>}
   */
  async remove(key) {
    return new Promise((resolve, reject) => {
      try {
        uni.removeStorageSync(key);
        resolve();
      } catch (error) {
        console.error('Storage remove error:', error);
        reject(error);
      }
    });
  },

  /**
   * 清空所有数据
   * @returns {Promise<void>}
   */
  async clear() {
    return new Promise((resolve, reject) => {
      try {
        uni.clearStorageSync();
        resolve();
      } catch (error) {
        console.error('Storage clear error:', error);
        reject(error);
      }
    });
  }
};

/**
 * 数据验证工具
 */
export const validateUtil = {
  /**
   * 验证是否为有效的学号格式
   * @param {string} studentId - 学号
   * @returns {boolean} 是否有效
   */
  isValidStudentId(studentId) {
    return /^\d{6,20}$/.test(studentId);
  },

  /**
   * 验证是否为有效的手机号
   * @param {string} phone - 手机号
   * @returns {boolean} 是否有效
   */
  isValidPhone(phone) {
    return /^1[3-9]\d{9}$/.test(phone);
  },

  /**
   * 验证密码强度
   * @param {string} password - 密码
   * @returns {Object} 验证结果
   */
  checkPasswordStrength(password) {
    let strength = 0;
    let message = '';
    
    if (password.length < 6) {
      return { strength: 0, message: '密码长度至少6位' };
    }
    
    if (password.length >= 8) strength++;
    if (/[a-z]/.test(password)) strength++;
    if (/[A-Z]/.test(password)) strength++;
    if (/[0-9]/.test(password)) strength++;
    if (/[^a-zA-Z0-9]/.test(password)) strength++;
    
    switch (strength) {
      case 0:
      case 1:
        message = '密码强度弱';
        break;
      case 2:
      case 3:
        message = '密码强度中等';
        break;
      case 4:
      case 5:
        message = '密码强度强';
        break;
    }
    
    return { strength, message };
  }
};

/**
 * 页面跳转工具
 */
export const navigateUtil = {
  /**
   * 跳转到登录页（清除所有页面栈）
   */
  toLogin() {
    uni.reLaunch({
      url: '/pages/login/login'
    });
  },

  /**
   * 跳转到Tab页面
   * @param {string} url - Tab页面路径
   */
  toTab(url) {
    uni.switchTab({
      url
    });
  },

  /**
   * 跳转到普通页面
   * @param {string} url - 页面路径
   */
  toPage(url) {
    uni.navigateTo({
      url
    });
  },

  /**
   * 返回上一页
   * @param {number} delta - 返回层级，默认1
   */
  back(delta = 1) {
    uni.navigateBack({
      delta
    });
  }
};